oracle.pgx.api

## Class Analyst

- java.lang.Object
- - oracle.pgx.api.Destroyable
  - - oracle.pgx.api.Analyst

- All Implemented Interfaces:
    AutoCloseable

      public class Analyst
      extends Destroyable

  The Analyst gives access to all built-in algorithms of PGX. Unlike other classes inside this package, the Analyst is not stateless. It creates session-bound transient data to hold the result of algorithms and keeps track of them. Once `Destroyable.destroy()` is invoked, all transient data returned by the Analyst gets freed and cannot be used anymore.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `approximateVertexBetweennessCentrality(PgxGraph graph, int k)` Blocking version of `#approximateVertexBetweennessCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `approximateVertexBetweennessCentralityAsync(PgxGraph graph, int k)` Approximate vertex betweenness centrality (without considering edge length).
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph, PgxVertex<ID>... seeds)` Blocking version of `#approximateVertexBetweennessCentralityFromSeedsAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph, PgxVertex<ID>... seeds)` Approximate vertex betweenness centrality (without considering edge length).
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `closenessCentralityDoubleLength(PgxGraph graph, EdgeProperty<Double> cost)` Blocking version of `#closenessCentralityDoubleLengthAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `closenessCentralityDoubleLengthAsync(PgxGraph graph, EdgeProperty<Double> cost)` Compute closed centrality.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `closenessCentralityUnitLength(PgxGraph graph)` Blocking version of `#closenessCentralityUnitLengthAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `closenessCentralityUnitLengthAsync(PgxGraph graph)` Compute closed centrality.
    `<ID extends Comparable<ID>> Partition<ID>` | `communitiesLabelPropagation(PgxGraph graph)` Blocking version of `#communitiesLabelPropagationAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Partition<ID>>` | `communitiesLabelPropagationAsync(PgxGraph graph)` Detect communities using parallel label propagation.
    `long` | `countTriangles(PgxGraph graph, boolean sortVerticesByDegree)` Blocking version of `#countTrianglesAsync()`.
    `PgxFuture<Long>` | `countTrianglesAsync(PgxGraph graph, boolean sortVerticesByDegree)` Counts the number of 'triads' in the given undirected graph.
    `<ID extends Comparable<ID>> VertexProperty<ID,Integer>` | `degreeCentrality(PgxGraph graph)` Blocking version of `#degreeCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>` | `degreeCentralityAsync(PgxGraph graph)` Compute degree centrality.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `eigenvectorCentrality(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge)` Blocking version of `#eigenvectorCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `eigenvectorCentralityAsync(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge)` Compute eigenvector centrality using power iteration (with L1 norm).
    `<ID extends Comparable<ID>> AllPaths<ID>` | `fattestPath(PgxGraph graph, ID rootId, EdgeProperty<Double> capacity)` Convenience wrapper around `fattestPath(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of a `PgxVertex`.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `fattestPath(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<Double> capacity)` Blocking version of `#fattestPathAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `fattestPathAsync(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<Double> capacity)` Fattest Tree Algorithm - Computes the fattest path from a source vertex to all vertices in the graph.
    `PgxSession` | `getSession()` Gets the session.
    `<ID extends Comparable<ID>> Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>` | `hits(PgxGraph graph, int max)` Blocking version of `#hitsAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>>` | `hitsAsync(PgxGraph graph, int max)` Classic HITS algorithm (Hyperlink-Induced Topic Search, aka.
    `<ID extends Comparable<ID>> VertexProperty<ID,Integer>` | `inDegreeCentrality(PgxGraph graph)` Blocking version of `#inDegreeCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>` | `inDegreeCentralityAsync(PgxGraph graph)` Compute in-degree centrality.
    `PgxMap<Integer,Long>` | `inDegreeDistribution(PgxGraph graph)` Blocking version of `#inDegreeDistributionAsync()`.
    `PgxFuture<PgxMap<Integer,Long>>` | `inDegreeDistributionAsync(PgxGraph graph)` Computes the indegree distribution of the given graph and stores it in a map.
    `<ID extends Comparable<ID>> VertexProperty<ID,Integer>` | `outDegreeCentrality(PgxGraph graph)` Blocking version of `#outDegreeCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>` | `outDegreeCentralityAsync(PgxGraph graph)` Compute out-degree centrality.
    `PgxMap<Integer,Long>` | `outDegreeDistribution(PgxGraph graph)` Blocking version of `#outDegreeDistributionAsync()`.
    `PgxFuture<PgxMap<Integer,Long>>` | `outDegreeDistributionAsync(PgxGraph graph)` Computes the outdegree distribution of the given graph and stores it in a map.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `pagerank(PgxGraph graph, double e, double d, int max)` Blocking version of `#pagerankAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `pagerankAsync(PgxGraph graph, double e, double d, int max)` Classic pagerank algorithm.
    `<ID extends Comparable<ID>> Pair<Scalar<Double>,Scalar<Double>>` | `partitionConductance(PgxGraph graph, Partition<ID> components)` Blocking version of `#partitionConductanceAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Pair<Scalar<Double>,Scalar<Double>>>` | `partitionConductanceAsync(PgxGraph graph, Partition<ID> partition)` Compute the conductance of a partition.
    `<ID extends Comparable<ID>> Scalar<Double>` | `partitionModularity(PgxGraph graph, Partition<ID> components)` Blocking version of `#partitionModularityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Scalar<Double>>` | `partitionModularityAsync(PgxGraph graph, Partition<ID> partition)` Compute the modularity of a partition.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `personalizedPagerank(PgxGraph graph, ID vertexId, double e, double d, int max)` Convenience wrapper around `personalizedPagerank(PgxGraph, PgxVertex, double, double, int)` taking a vertex ID instead of a `PgxVertex`.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `personalizedPagerank(PgxGraph graph, PgxVertex<ID> v, double e, double d, int max)` Blocking version of `personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int)`.
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `personalizedPagerank(PgxGraph graph, VertexSet<ID> vertices, double e, double d, int max)` Blocking version of `personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int)`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `personalizedPagerankAsync(PgxGraph graph, PgxVertex<ID> v, double e, double d, int max)` Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given vertex v.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `personalizedPagerankAsync(PgxGraph graph, VertexSet<ID> vertices, double e, double d, int max)` Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given set of vertices.
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `salsa(BipartiteGraph graph, int k)` Blocking version of `salsaAsync(BipartiteGraph, int)`.
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `salsa(BipartiteGraph graph, int k, double maxDiff, double d, int maxIter)` Blocking version of `salsaAsync(BipartiteGraph, int, double, double, int)`.
    `<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>` | `salsaAsync(BipartiteGraph graph, int k)` Convenience method around `salsaAsync(BipartiteGraph, int, double, double, int)` using maxDiff = 0.01 d = 0.85 maxIter = 1.10
    `<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>` | `salsaAsync(BipartiteGraph graph, int k, double maxDiff, double d, int maxIter)` SALSA recommendation algorithm.
    `<ID extends Comparable<ID>> Partition<ID>` | `sccKosaraju(PgxGraph graph)` Blocking version of `#sccKosarajuAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Partition<ID>>` | `sccKosarajuAsync(PgxGraph graph)` Find strongly connected components using Kosaraju's algorithm.
    `<ID extends Comparable<ID>> Partition<ID>` | `sccTarjan(PgxGraph graph)` Blocking version of `#sccTarjanAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Partition<ID>>` | `sccTarjanAsync(PgxGraph graph)` Find strongly connected components using Tarjan's algorithm.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathBellmanFord(PgxGraph graph, ID srcId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathBellmanFord(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Blocking version of `#shortestPathBellmanFordAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `shortestPathBellmanFordAsync(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Compute single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathBellmanFordReverse(PgxGraph graph, ID srcId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathBellmanFordReverse(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Blocking version of `#shortestPathBellmanFordReverseAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `shortestPathBellmanFordReverseAsync(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Compute reverse single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathDijkstra(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathDijkstra(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Blocking version of `#shortestPathDijkstraAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>` | `shortestPathDijkstraAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Compute shortest path using Dijkstra's algorithm.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathDijkstraBidirectional(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathDijkstraBidirectional(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Blocking version of `#shortestPathDijkstraBidirectionalAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>` | `shortestPathDijkstraBidirectionalAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Compute shortest path using a bi-directional Dijkstra variant.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathFilteredDijkstra(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost, GraphFilter filterExpr)` Convenience wrapper around `shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathFilteredDijkstra(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Blocking version of `#shortestPathFilteredDijkstraAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>` | `shortestPathFilteredDijkstraAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Compute shortest path using Dijkstra's algorithm on a filtered graph The filter specified by the given filter expression is applied on each edge during traversal of the graph.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathFilteredDijkstraBidirectional(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost, GraphFilter filterExpr)` Convenience wrapper around `shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
    `<ID extends Comparable<ID>> PgxPath<ID>` | `shortestPathFilteredDijkstraBidirectional(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Blocking version of `#shortestPathFilteredDijkstraBidirectionalAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>` | `shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Compute shortest path using a bi-directional Dijkstra variant on a filtered graph.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathHopDist(PgxGraph graph, ID srcId)` Convenience wrapper around `shortestPathHopDist(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathHopDist(PgxGraph graph, PgxVertex<ID> src)` Blocking version of `#shortestPathHopDistAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `shortestPathHopDistAsync(PgxGraph graph, PgxVertex<ID> src)` Compute hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathHopDistReverse(PgxGraph graph, ID srcId)` Convenience wrapper around `shortestPathHopDistReverse(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
    `<ID extends Comparable<ID>> AllPaths<ID>` | `shortestPathHopDistReverse(PgxGraph graph, PgxVertex<ID> src)` Blocking version of `#shortestPathHopDistReverseAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>` | `shortestPathHopDistReverseAsync(PgxGraph graph, PgxVertex<ID> src)` Compute reverse hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
    `String` | `toString()`
    `<ID extends Comparable<ID>> VertexProperty<ID,Double>` | `vertexBetweennessCentrality(PgxGraph graph)` Blocking version of `#vertexBetweennessCentralityAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>` | `vertexBetweennessCentralityAsync(PgxGraph graph)` Compute vertex betweenness centrality (without considering edge length).
    `<ID extends Comparable<ID>> Partition<ID>` | `wcc(PgxGraph graph)` Blocking version of `#wccAsync()`.
    `<ID extends Comparable<ID>> PgxFuture<Partition<ID>>` | `wccAsync(PgxGraph graph)` Find weakly connected components through label propagation time complexity: O(E * D) with E = number of edges, D = diameter of the graph
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `whomToFollow(PgxGraph graph, ID vertexId, int max)` Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int)` taking a vertex ID instead of a `PgxVertex`.
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `whomToFollow(PgxGraph graph, ID vertexId, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` taking a vertex ID instead of a `PgxVertex`.
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `whomToFollow(PgxGraph graph, PgxVertex<ID> vertex, int max)` Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int)`.
    `<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>` | `whomToFollow(PgxGraph graph, PgxVertex<ID> vertex, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)`.
    `<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>` | `whomToFollowAsync(PgxGraph graph, PgxVertex<ID> vertex, int max)` Convenience method around `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` using circleOfTrustSize = 500 randomWalkSteps = 50000 randomWalkResetProbablitiy = 0.15 salsaDampingFactor = 0.85 salsaMaxIterations = 1.10 salsaMaxDiff = 0.01
    `<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>` | `whomToFollowAsync(PgxGraph graph, PgxVertex<ID> vertex, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` The Who to Follow recommendation algorithm by Twitter, Inc.

    - ### Methods inherited from class oracle.pgx.api.Destroyable

      `close, destroy, destroyAsync`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Method Detail

    - #### approximateVertexBetweennessCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> approximateVertexBetweennessCentrality(PgxGraph graph,
                                                                                                                    int k)
                                                                                                  throws ExecutionException,
                                                                                                         InterruptedException

      Blocking version of `#approximateVertexBetweennessCentralityAsync()`. Calls `#approximateVertexBetweennessCentralityAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### approximateVertexBetweennessCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> approximateVertexBetweennessCentralityAsync(PgxGraph graph,
                                                                                                                     int k)

      Approximate vertex betweenness centrality (without considering edge length). The algorithm performs a BFS only from randomly selected k seed vertices instead of every vertex. time complexity: O(K * E) with E = number of edges, K is a given constant (# of seed vertices)
      Parameters:
        `graph` - graph name
        `k` - how many random selected seed vertices to use
      Returns:
        VertexProperty holding the result as a double

    - #### approximateVertexBetweennessCentralityFromSeeds

          @SafeVarargs
          @Generated(value="src/python/synchronize.py")
          public final <ID extends Comparable<ID>> VertexProperty<ID,Double> approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph,
                                                                                                                                         PgxVertex<ID>... seeds)
                                                                                                                 throws ExecutionException,
                                                                                                                        InterruptedException

      Blocking version of `#approximateVertexBetweennessCentralityFromSeedsAsync()`. Calls `#approximateVertexBetweennessCentralityFromSeedsAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### approximateVertexBetweennessCentralityFromSeedsAsync

          @SafeVarargs
          public final <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph,
                                                                                                                                          PgxVertex<ID>... seeds)

      Approximate vertex betweenness centrality (without considering edge length). The algorithm performs a BFS only from the given seed vertices instead of every vertex. time complexity: O(K * E) with E = number of edges, K is a given constant (# of seed vertices)
      Parameters:
        `graph` - graph
        `seeds` - collection
      Returns:
        VertexProperty holding the result as a double

    - #### closenessCentralityDoubleLength

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> closenessCentralityDoubleLength(PgxGraph graph,
                                                                                                             EdgeProperty<Double> cost)
                                                                                           throws ExecutionException,
                                                                                                  InterruptedException

      Blocking version of `#closenessCentralityDoubleLengthAsync()`. Calls `#closenessCentralityDoubleLengthAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### closenessCentralityDoubleLengthAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> closenessCentralityDoubleLengthAsync(PgxGraph graph,
                                                                                                              EdgeProperty<Double> cost)

      Compute closed centrality. The algorithm computes bellman-ford from every vertex in the graph, and thus is computationally very expensive. Note: The algorithm is only defined on a strongly connected graph. time complexity: O(N * E * d) with E = number of edges, N = number of vertices, d = path-length diameter of graph
      Parameters:
        `graph` - graph
        `cost` - Edge Property of the cost
      Returns:
        the Vertex Property holding the result as a double

    - #### closenessCentralityUnitLength

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> closenessCentralityUnitLength(PgxGraph graph)
                                                                                         throws ExecutionException,
                                                                                                InterruptedException

      Blocking version of `#closenessCentralityUnitLengthAsync()`. Calls `#closenessCentralityUnitLengthAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### closenessCentralityUnitLengthAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> closenessCentralityUnitLengthAsync(PgxGraph graph)

      Compute closed centrality. The algorithm computes BFS from every vertex in the graph, and thus is computationally very expensive. Note: The algorithm is only defined on a strongly connected graph. time complexity: O(N * E) with E = number of edges, N = number of vertices
      Parameters:
        `graph` - graph
      Returns:
        the Vertex Property holding the result as a double

    - #### communitiesLabelPropagation

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Partition<ID> communitiesLabelPropagation(PgxGraph graph)
                                                                           throws ExecutionException,
                                                                                  InterruptedException

      Blocking version of `#communitiesLabelPropagationAsync()`. Calls `#communitiesLabelPropagationAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### communitiesLabelPropagationAsync

          public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph)

      Detect communities using parallel label propagation. time complexity: O(E * k) with E = number of edges, k is constant
      Parameters:
        `graph` - graph
      Returns:
        a PgxComponent holding the result

    - #### countTriangles

          @Generated(value="src/python/synchronize.py")
          public long countTriangles(PgxGraph graph,
                                           boolean sortVerticesByDegree)
                              throws ExecutionException,
                                     InterruptedException

      Blocking version of `#countTrianglesAsync()`. Calls `#countTrianglesAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### countTrianglesAsync

          public PgxFuture<Long> countTrianglesAsync(PgxGraph graph,
                                            boolean sortVerticesByDegree)

      Counts the number of 'triads' in the given undirected graph. The algorithm is only defined on undirected graphs, this method therefore first creates an undirected copy of the given graph. After Time complexity: O(E * d) with E = number of edges, d = degree of graph
      Parameters:
        `graph` - graph
        `sortVerticesByDegree` - if `true`, the undirected copy of the graph will be sorted by degree. You can use this flag to trade memory for speed. If sorted, the algorithm usually terminates faster, but the peak memory consumption increases.
      Returns:
        number of triangles

    - #### degreeCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Integer> degreeCentrality(PgxGraph graph)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

      Blocking version of `#degreeCentralityAsync()`. Calls `#degreeCentralityAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### degreeCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> degreeCentralityAsync(PgxGraph graph)

      Compute degree centrality. time complexity: O(E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        VertexProperty holding the result as an integer

    - #### eigenvectorCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> eigenvectorCentrality(PgxGraph graph,
                                                                                                   int max,
                                                                                                   double maxDiff,
                                                                                                   boolean useL2Norm,
                                                                                                   boolean useInEdge)
                                                                                 throws ExecutionException,
                                                                                        InterruptedException

      Blocking version of `#eigenvectorCentralityAsync()`. Calls `#eigenvectorCentralityAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### eigenvectorCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> eigenvectorCentralityAsync(PgxGraph graph,
                                                                                                    int max,
                                                                                                    double maxDiff,
                                                                                                    boolean useL2Norm,
                                                                                                    boolean useInEdge)

      Compute eigenvector centrality using power iteration (with L1 norm). This algorithm is similar to Pagerank. time complexity: O(K * E) with E = number of edges, K is a given constant (max iterations)
      Type Parameters:
        `ID` - the generic type
      Parameters:
        `graph` - graph where used for the algorithm
        `max` - maximum number of iterations
        `maxDiff` - maximum error for terminating the iteration
        `useL2Norm` - true- use L2Norm for normalization. false - use L1Norm
        `useInEdge` - true- compute 'left' eigenvector, false - compute 'right' eigenvector
      Returns:
        Vertex Property holding the result as a double

    - #### fattestPath

          public <ID extends Comparable<ID>> AllPaths<ID> fattestPath(PgxGraph graph,
                                                             ID rootId,
                                                             EdgeProperty<Double> capacity)
                                                          throws ExecutionException,
                                                                 InterruptedException

      Convenience wrapper around `fattestPath(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of a `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### fattestPath

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> fattestPath(PgxGraph graph,
                                                                            PgxVertex<ID> root,
                                                                            EdgeProperty<Double> capacity)
                                                          throws ExecutionException,
                                                                 InterruptedException

      Blocking version of `#fattestPathAsync()`. Calls `#fattestPathAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### fattestPathAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> fattestPathAsync(PgxGraph graph,
                                                                             PgxVertex<ID> root,
                                                                             EdgeProperty<Double> capacity)

      Fattest Tree Algorithm - Computes the fattest path from a source vertex to all vertices in the graph. The fattest path between two vertices is the path with the highest possible minimum edge capacity.
      Parameters:
        `graph` - graph
        `capacity` - edge property containing the capacity of each edge. Capacity may be negative. In case of an undirected graph, the capacity of the forward and backward edge should be the same.
        `root` - the starting vertex of the algorithm
      Returns:
        AllPaths<ID> holds the minimum capacity of the path leading to this vertex. Will be `Double.POSITIVE_INFINITY` for the root vertex and 0.0 for all vertices not connected to root.

    - #### getSession

          public PgxSession getSession()

      Gets the session.
      Returns:
        the PGX session

    - #### hits

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>> hits(PgxGraph graph,
                                                                                                                  int max)
                                                                                                                       throws ExecutionException,
                                                                                                                              InterruptedException

      Blocking version of `#hitsAsync()`. Calls `#hitsAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### hitsAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>> hitsAsync(PgxGraph graph,
                                                                                                                   int max)

      Classic HITS algorithm (Hyperlink-Induced Topic Search, aka. Hubs and Authorities). The implementation uses an iterative method. At each iteration step, the hub and the authority values of all the vertices in the graph are computed . time complexity: O(K * E) with E = number of edges, K is a given constant (max iterations)
      Parameters:
        `graph` - graph
        `max` - maximum number of iterations
      Returns:
        Pair of Vertex Properties holding the results as a doubles

    - #### inDegreeCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Integer> inDegreeCentrality(PgxGraph graph)
                                                                               throws ExecutionException,
                                                                                      InterruptedException

      Blocking version of `#inDegreeCentralityAsync()`. Calls `#inDegreeCentralityAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### inDegreeCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> inDegreeCentralityAsync(PgxGraph graph)

      Compute in-degree centrality. time complexity: O(E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        VertexProperty holding the result as an integer

    - #### inDegreeDistribution

          @Generated(value="src/python/synchronize.py")
          public PgxMap<Integer,Long> inDegreeDistribution(PgxGraph graph)
                                                    throws ExecutionException,
                                                           InterruptedException

      Blocking version of `#inDegreeDistributionAsync()`. Calls `#inDegreeDistributionAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### inDegreeDistributionAsync

          public PgxFuture<PgxMap<Integer,Long>> inDegreeDistributionAsync(PgxGraph graph)

      Computes the indegree distribution of the given graph and stores it in a map.
      Parameters:
        `graph` - graph
      Returns:
        map that will hold the mapping indegree -> #vertices with that indegree

    - #### outDegreeCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Integer> outDegreeCentrality(PgxGraph graph)
                                                                                throws ExecutionException,
                                                                                       InterruptedException

      Blocking version of `#outDegreeCentralityAsync()`. Calls `#outDegreeCentralityAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### outDegreeCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> outDegreeCentralityAsync(PgxGraph graph)

      Compute out-degree centrality. time complexity: O(E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        VertexProperty holding the result as an integer

    - #### outDegreeDistribution

          @Generated(value="src/python/synchronize.py")
          public PgxMap<Integer,Long> outDegreeDistribution(PgxGraph graph)
                                                     throws ExecutionException,
                                                            InterruptedException

      Blocking version of `#outDegreeDistributionAsync()`. Calls `#outDegreeDistributionAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### outDegreeDistributionAsync

          public PgxFuture<PgxMap<Integer,Long>> outDegreeDistributionAsync(PgxGraph graph)

      Computes the outdegree distribution of the given graph and stores it in a map.
      Parameters:
        `graph` - graph
      Returns:
        map that will hold the mapping outdegree -> #vertices with that outdegree

    - #### pagerank

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> pagerank(PgxGraph graph,
                                                                                      double e,
                                                                                      double d,
                                                                                      int max)
                                                                    throws ExecutionException,
                                                                           InterruptedException

      Blocking version of `#pagerankAsync()`. Calls `#pagerankAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### pagerankAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> pagerankAsync(PgxGraph graph,
                                                                                       double e,
                                                                                       double d,
                                                                                       int max)

      Classic pagerank algorithm. Time complexity: O(E * K) with E = number of edges, K is a given constant (max iterations)
      Parameters:
        `graph` - graph
        `e` - maximum error for terminating the iteration
        `d` - damping factor
        `max` - maximum number of iterations
      Returns:
        Vertex Property holding the result as a double

    - #### partitionConductance

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<Scalar<Double>,Scalar<Double>> partitionConductance(PgxGraph graph,
                                                                                                            Partition<ID> components)
                                                                   throws ExecutionException,
                                                                          InterruptedException

      Blocking version of `#partitionConductanceAsync()`. Calls `#partitionConductanceAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### partitionConductanceAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<Scalar<Double>,Scalar<Double>>> partitionConductanceAsync(PgxGraph graph,
                                                                                                             Partition<ID> partition)

      Compute the conductance of a partition.
      Parameters:
        `graph` - graph
        `partition` - the partition to analyze
      Returns:
        a pair holding the average conductance (first scalar value) and the minimum conductance (second scalar value)

    - #### partitionModularity

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Scalar<Double> partitionModularity(PgxGraph graph,
                                                                                      Partition<ID> components)
                                             throws ExecutionException,
                                                    InterruptedException

      Blocking version of `#partitionModularityAsync()`. Calls `#partitionModularityAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### partitionModularityAsync

          public <ID extends Comparable<ID>> PgxFuture<Scalar<Double>> partitionModularityAsync(PgxGraph graph,
                                                                                       Partition<ID> partition)

      Compute the modularity of a partition.
      Parameters:
        `graph` - graph
        `partition` - the partition to analyze
      Returns:
        scalar (of type double) to hold modularity
      See Also:
        http://en.wikipedia.org/wiki/Modularity_(networks) Note: this algorithm is in-efficient if numComponents is big (i.e. O(N))

    - #### personalizedPagerank

          public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                                   ID vertexId,
                                                                                   double e,
                                                                                   double d,
                                                                                   int max)
                                                                                throws ExecutionException,
                                                                                       InterruptedException

      Convenience wrapper around `personalizedPagerank(PgxGraph, PgxVertex, double, double, int)` taking a vertex ID instead of a `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### personalizedPagerank

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                                                  PgxVertex<ID> v,
                                                                                                  double e,
                                                                                                  double d,
                                                                                                  int max)
                                                                                throws ExecutionException,
                                                                                       InterruptedException

      Blocking version of `personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int)`. Calls `personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int)` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### personalizedPagerank

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                                                  VertexSet<ID> vertices,
                                                                                                  double e,
                                                                                                  double d,
                                                                                                  int max)
                                                                                throws ExecutionException,
                                                                                       InterruptedException

      Blocking version of `personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int)`. Calls `personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int)` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### personalizedPagerankAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> personalizedPagerankAsync(PgxGraph graph,
                                                                                                   PgxVertex<ID> v,
                                                                                                   double e,
                                                                                                   double d,
                                                                                                   int max)

      Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given vertex v. That is the probability of ending at each vertex u, when performing random walk from the given vertex v with probability of c to restart from the start vertex. The implementation directly emulates random-walk via Monte-Carlo method. time complexity: O(K), K is a given constant (max iterations)
      Parameters:
        `graph` - graph
        `v` - vertex
        `e` - maximum error for terminating the iteration
        `d` - damping factor
        `max` - maximum number of iterations
      Returns:
        Vertex Property holding the result as a double

    - #### personalizedPagerankAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> personalizedPagerankAsync(PgxGraph graph,
                                                                                                   VertexSet<ID> vertices,
                                                                                                   double e,
                                                                                                   double d,
                                                                                                   int max)

      Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given set of vertices.
      Parameters:
        `graph` - graph
        `vertices` - input vertices
        `e` - maximum error for terminating the iteration
        `d` - damping factor
        `max` - maximum number of iterations
      Returns:
        Vertex Property holding the result as a double

    - #### salsa

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> salsa(BipartiteGraph graph,
                                                                                                     int k)
                                                                                                          throws ExecutionException,
                                                                                                                 InterruptedException

      Blocking version of `salsaAsync(BipartiteGraph, int)`. Calls `salsaAsync(BipartiteGraph, int)` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### salsa

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> salsa(BipartiteGraph graph,
                                                                                                     int k,
                                                                                                     double maxDiff,
                                                                                                     double d,
                                                                                                     int maxIter)
                                                                                                          throws ExecutionException,
                                                                                                                 InterruptedException

      Blocking version of `salsaAsync(BipartiteGraph, int, double, double, int)`. Calls `salsaAsync(BipartiteGraph, int, double, double, int)` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### salsaAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> salsaAsync(BipartiteGraph graph,
                                                                                                      int k)

      Convenience method around `salsaAsync(BipartiteGraph, int, double, double, int)` using
      - maxDiff = 0.01
      - d = 0.85
      - maxIter = 1.10

    - #### salsaAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> salsaAsync(BipartiteGraph graph,
                                                                                                      int k,
                                                                                                      double maxDiff,
                                                                                                      double d,
                                                                                                      int maxIter)

      SALSA recommendation algorithm.
      Parameters:
        `graph` - a bipartite graph
        `k` - the top K vertices will be returned in hub_recs and auth_recs (so K+K vertices will be returned)
        `maxDiff` - the maximum diff
        `d` - damping factor
        `maxIter` - the maximum number of iterations
      Returns:
        a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry
      See Also:
        R. Lempel and S. Moran. SALSA: The Stochastic Approach for Link-Structure Analysis

    - #### sccKosaraju

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Partition<ID> sccKosaraju(PgxGraph graph)
                                                           throws ExecutionException,
                                                                  InterruptedException

      Blocking version of `#sccKosarajuAsync()`. Calls `#sccKosarajuAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sccKosarajuAsync

          public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> sccKosarajuAsync(PgxGraph graph)

      Find strongly connected components using Kosaraju's algorithm. This algorithm is parallelized, however, it has a larger constant factor than Tarjan's algorithm and thus may be slower than Tarjan's with small number of threads. time complexity: O(E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        connected components found

    - #### sccTarjan

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Partition<ID> sccTarjan(PgxGraph graph)
                                                         throws ExecutionException,
                                                                InterruptedException

      Blocking version of `#sccTarjanAsync()`. Calls `#sccTarjanAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### sccTarjanAsync

          public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> sccTarjanAsync(PgxGraph graph)

      Find strongly connected components using Tarjan's algorithm. This algorithm is sequential by nature. time complexity: O(E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        strongly connected components found

    - #### shortestPathBellmanFord

          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFord(PgxGraph graph,
                                                                         ID srcId,
                                                                         EdgeProperty<Double> cost)
                                                                      throws ExecutionException,
                                                                             InterruptedException

      Convenience wrapper around `shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathBellmanFord

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFord(PgxGraph graph,
                                                                                        PgxVertex<ID> src,
                                                                                        EdgeProperty<Double> cost)
                                                                      throws ExecutionException,
                                                                             InterruptedException

      Blocking version of `#shortestPathBellmanFordAsync()`. Calls `#shortestPathBellmanFordAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathBellmanFordAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathBellmanFordAsync(PgxGraph graph,
                                                                                         PgxVertex<ID> src,
                                                                                         EdgeProperty<Double> cost)

      Compute single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
      Parameters:
        `graph` - graph
        `cost` - edge property (of type double) holding the edge costs of the graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
      Returns:
        a AllPaths holding the result

    - #### shortestPathBellmanFordReverse

          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFordReverse(PgxGraph graph,
                                                                                ID srcId,
                                                                                EdgeProperty<Double> cost)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

      Convenience wrapper around `shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathBellmanFordReverse

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFordReverse(PgxGraph graph,
                                                                                               PgxVertex<ID> src,
                                                                                               EdgeProperty<Double> cost)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

      Blocking version of `#shortestPathBellmanFordReverseAsync()`. Calls `#shortestPathBellmanFordReverseAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathBellmanFordReverseAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathBellmanFordReverseAsync(PgxGraph graph,
                                                                                                PgxVertex<ID> src,
                                                                                                EdgeProperty<Double> cost)

      Compute reverse single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
      Parameters:
        `graph` - graph
        `cost` - edge property (of type double) holding the edge costs of the graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)

    - #### shortestPathDijkstra

          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstra(PgxGraph graph,
                                                                     ID srcId,
                                                                     ID dstId,
                                                                     EdgeProperty<Double> cost)
                                                                  throws ExecutionException,
                                                                         InterruptedException

      Convenience wrapper around `shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathDijkstra

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstra(PgxGraph graph,
                                                                                    PgxVertex<ID> src,
                                                                                    PgxVertex<ID> dst,
                                                                                    EdgeProperty<Double> cost)
                                                                  throws ExecutionException,
                                                                         InterruptedException

      Blocking version of `#shortestPathDijkstraAsync()`. Calls `#shortestPathDijkstraAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathDijkstraAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathDijkstraAsync(PgxGraph graph,
                                                                                     PgxVertex<ID> src,
                                                                                     PgxVertex<ID> dst,
                                                                                     EdgeProperty<Double> cost)

      Compute shortest path using Dijkstra's algorithm. Time complexity: O(N log N) with N = number of vertices
      Parameters:
        `graph` - graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `dst` - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `cost` - edge property (of type double) holding the edge costs of the graph
      Returns:
        a PgxPath holding the result

    - #### shortestPathDijkstraBidirectional

          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstraBidirectional(PgxGraph graph,
                                                                                  ID srcId,
                                                                                  ID dstId,
                                                                                  EdgeProperty<Double> cost)
                                                                               throws ExecutionException,
                                                                                      InterruptedException

      Convenience wrapper around `shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathDijkstraBidirectional

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstraBidirectional(PgxGraph graph,
                                                                                                 PgxVertex<ID> src,
                                                                                                 PgxVertex<ID> dst,
                                                                                                 EdgeProperty<Double> cost)
                                                                               throws ExecutionException,
                                                                                      InterruptedException

      Blocking version of `#shortestPathDijkstraBidirectionalAsync()`. Calls `#shortestPathDijkstraBidirectionalAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathDijkstraBidirectionalAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathDijkstraBidirectionalAsync(PgxGraph graph,
                                                                                                  PgxVertex<ID> src,
                                                                                                  PgxVertex<ID> dst,
                                                                                                  EdgeProperty<Double> cost)

      Compute shortest path using a bi-directional Dijkstra variant. Bi-directional Dijkstra is faster than Dijkstra by a constant factor. time complexity: O(N log N) with N = number of vertices
      Parameters:
        `graph` - graph
        `cost` - the edge property (of type double) holding the edge costs of the graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `dst` - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
      Returns:
        a PgxPath holding the result

    - #### shortestPathFilteredDijkstra

          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstra(PgxGraph graph,
                                                                             ID srcId,
                                                                             ID dstId,
                                                                             EdgeProperty<Double> cost,
                                                                             GraphFilter filterExpr)
                                                                          throws ExecutionException,
                                                                                 InterruptedException

      Convenience wrapper around `shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathFilteredDijkstra

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstra(PgxGraph graph,
                                                                                            PgxVertex<ID> src,
                                                                                            PgxVertex<ID> dst,
                                                                                            EdgeProperty<Double> cost,
                                                                                            GraphFilter filterExpr)
                                                                          throws ExecutionException,
                                                                                 InterruptedException

      Blocking version of `#shortestPathFilteredDijkstraAsync()`. Calls `#shortestPathFilteredDijkstraAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathFilteredDijkstraAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathFilteredDijkstraAsync(PgxGraph graph,
                                                                                             PgxVertex<ID> src,
                                                                                             PgxVertex<ID> dst,
                                                                                             EdgeProperty<Double> cost,
                                                                                             GraphFilter filterExpr)

      Compute shortest path using Dijkstra's algorithm on a filtered graph The filter specified by the given filter expression is applied on each edge during traversal of the graph. If it evaluates to false, the edge is skipped. time complexity: O(N log N) with N = number of vertices
      Parameters:
        `graph` - graph
        `cost` - edge property (of type double) holding the edge costs of the graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `dst` - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `filterExpr` - filter expression that is evaluated during traversal
      Returns:
        a PgxPath holding the result

    - #### shortestPathFilteredDijkstraBidirectional

          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
                                                                                          ID srcId,
                                                                                          ID dstId,
                                                                                          EdgeProperty<Double> cost,
                                                                                          GraphFilter filterExpr)
                                                                                       throws ExecutionException,
                                                                                              InterruptedException

      Convenience wrapper around `shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathFilteredDijkstraBidirectional

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
                                                                                                         PgxVertex<ID> src,
                                                                                                         PgxVertex<ID> dst,
                                                                                                         EdgeProperty<Double> cost,
                                                                                                         GraphFilter filterExpr)
                                                                                       throws ExecutionException,
                                                                                              InterruptedException

      Blocking version of `#shortestPathFilteredDijkstraBidirectionalAsync()`. Calls `#shortestPathFilteredDijkstraBidirectionalAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathFilteredDijkstraBidirectionalAsync

          public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph,
                                                                                                          PgxVertex<ID> src,
                                                                                                          PgxVertex<ID> dst,
                                                                                                          EdgeProperty<Double> cost,
                                                                                                          GraphFilter filterExpr)

      Compute shortest path using a bi-directional Dijkstra variant on a filtered graph. Bi-directional Dijkstra is faster than Dijkstra by a constant factor. time complexity: O(N log N) with N = number of vertices
      Parameters:
        `graph` - graph
        `cost` - the edge property (of type double) holding the edge costs of the graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `dst` - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
        `filterExpr` - filter expression that is evaluated during traversal
      Returns:
        a PgxPath holding the result

    - #### shortestPathHopDist

          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDist(PgxGraph graph,
                                                                     ID srcId)
                                                                  throws ExecutionException,
                                                                         InterruptedException

      Convenience wrapper around `shortestPathHopDist(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathHopDist

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDist(PgxGraph graph,
                                                                                    PgxVertex<ID> src)
                                                                  throws ExecutionException,
                                                                         InterruptedException

      Blocking version of `#shortestPathHopDistAsync()`. Calls `#shortestPathHopDistAsync()` and waits for returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathHopDistAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathHopDistAsync(PgxGraph graph,
                                                                                     PgxVertex<ID> src)

      Compute hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
      Parameters:
        `graph` - graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
      Returns:
        a AllPaths holding the result

    - #### shortestPathHopDistReverse

          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDistReverse(PgxGraph graph,
                                                                            ID srcId)
                                                                         throws ExecutionException,
                                                                                InterruptedException

      Convenience wrapper around `shortestPathHopDistReverse(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### shortestPathHopDistReverse

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDistReverse(PgxGraph graph,
                                                                                           PgxVertex<ID> src)
                                                                         throws ExecutionException,
                                                                                InterruptedException

      Blocking version of `#shortestPathHopDistReverseAsync()`. Calls `#shortestPathHopDistReverseAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### shortestPathHopDistReverseAsync

          public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathHopDistReverseAsync(PgxGraph graph,
                                                                                            PgxVertex<ID> src)

      Compute reverse hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
      Parameters:
        `graph` - graph
        `src` - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
      Returns:
        a AllPaths holding the result

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### vertexBetweennessCentrality

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> VertexProperty<ID,Double> vertexBetweennessCentrality(PgxGraph graph)
                                                                                       throws ExecutionException,
                                                                                              InterruptedException

      Blocking version of `#vertexBetweennessCentralityAsync()`. Calls `#vertexBetweennessCentralityAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### vertexBetweennessCentralityAsync

          public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> vertexBetweennessCentralityAsync(PgxGraph graph)

      Compute vertex betweenness centrality (without considering edge length). The algorithm is implemented by performing BFS from every vertex in the graph. This can be expensive for large graphs. time complexity: O(N * E) with E = number of edges
      Parameters:
        `graph` - graph
      Returns:
        VertexProperty holding the result as a double

    - #### wcc

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Partition<ID> wcc(PgxGraph graph)
                                                   throws ExecutionException,
                                                          InterruptedException

      Blocking version of `#wccAsync()`. Calls `#wccAsync()` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### wccAsync

          public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> wccAsync(PgxGraph graph)

      Find weakly connected components through label propagation time complexity: O(E * D) with E = number of edges, D = diameter of the graph
      Parameters:
        `graph` - graph
      Returns:
        weakly connected components found

    - #### whomToFollow

          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                             ID vertexId,
                                                                                             int max)
                                                                                                                 throws ExecutionException,
                                                                                                                        InterruptedException

      Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int)` taking a vertex ID instead of a `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### whomToFollow

          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                             ID vertexId,
                                                                                             int max,
                                                                                             int circleOfTrustSize,
                                                                                             int randomWalkSteps,
                                                                                             double randomWalkResetProbablitiy,
                                                                                             double salsaDampingFactor,
                                                                                             int salsaMaxIterations,
                                                                                             double salsaMaxDiff)
                                                                                                                 throws ExecutionException,
                                                                                                                        InterruptedException

      Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` taking a vertex ID instead of a `PgxVertex`.
      Throws:
        `ExecutionException`
        `InterruptedException`

    - #### whomToFollow

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                                            PgxVertex<ID> vertex,
                                                                                                            int max)
                                                                                                                 throws ExecutionException,
                                                                                                                        InterruptedException

      Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int)`. Calls `whomToFollowAsync(PgxGraph, PgxVertex, int)` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### whomToFollow

          @Generated(value="src/python/synchronize.py")
          public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                                            PgxVertex<ID> vertex,
                                                                                                            int max,
                                                                                                            int circleOfTrustSize,
                                                                                                            int randomWalkSteps,
                                                                                                            double randomWalkResetProbablitiy,
                                                                                                            double salsaDampingFactor,
                                                                                                            int salsaMaxIterations,
                                                                                                            double salsaMaxDiff)
                                                                                                                 throws ExecutionException,
                                                                                                                        InterruptedException

      Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)`. Calls `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` and waits for the returned `PgxFuture` to complete.
      Throws:
        `InterruptedException` - if the caller thread gets interrupted while waiting for completion.
        `ExecutionException` - if any exception occurred during asynchronous execution. The actual exception will be nested.

    - #### whomToFollowAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> whomToFollowAsync(PgxGraph graph,
                                                                                                             PgxVertex<ID> vertex,
                                                                                                             int max)

      Convenience method around `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` using
      - circleOfTrustSize = 500
      - randomWalkSteps = 50000
      - randomWalkResetProbablitiy = 0.15
      - salsaDampingFactor = 0.85
      - salsaMaxIterations = 1.10
      - salsaMaxDiff = 0.01
      Parameters:
        `graph` - the graph
        `vertex` - the vertex
        `max` - maximum amount of recommendations to return
      Returns:
        a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry.

    - #### whomToFollowAsync

          public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> whomToFollowAsync(PgxGraph graph,
                                                                                                             PgxVertex<ID> vertex,
                                                                                                             int max,
                                                                                                             int circleOfTrustSize,
                                                                                                             int randomWalkSteps,
                                                                                                             double randomWalkResetProbablitiy,
                                                                                                             double salsaDampingFactor,
                                                                                                             int salsaMaxIterations,
                                                                                                             double salsaMaxDiff)

      The Who to Follow recommendation algorithm by Twitter, Inc. This algorithm performs a random walk from v and extracts the top visited vertices to determine the circle of trust. It then creates a `BipartiteGraph` with the circle of trust as left set and runs the `salsaAsync(BipartiteGraph, int, double, double, int)` recommendation algorithm on that graph to compute the hubs and authorities.
      Parameters:
        `graph` - the graph
        `vertex` - the vertex
        `max` - maximum amount of recommendations to return
        `circleOfTrustSize` - maximum size of the circle of trust
        `randomWalkSteps` - the amount of random walk steps
        `randomWalkResetProbablitiy` - likeliness of reset during the random walk (must be between 0.0 and 1.1)
        `salsaDampingFactor` - the damping factor for the SALSA algorithm
        `salsaMaxIterations` - the maximum amount of iterations for the SALSA algorithm
        `salsaMaxDiff` - the maximum diff value for the SALSA algorithm
      Returns:
        a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry.
      See Also:
        stanford.edu/~rezab/papers/wtf_overview.pdf

Copyright © 2015. All rights reserved.